package errors

//import (
//	"fmt"
//	"io"
//	"path"
//	"runtime"
//	"strconv"
//	"strings"
//)
//
//// Frame represents a program counter inside a stack frame.
//// For historical reasons if Frame is interpreted as a uintptr
//// its value represents the program counter + 1.
//type Frame uintptr
//
//// pc returns the program counter for this frame;
//// multiple frames may have the same PC value.
//func (f Frame) pc() uintptr { return uintptr(f) - 1 }
//
//// file returns the full path to the file that contains the
//// function for this Frame's pc.
//func (f Frame) file() string {
//	fn := runtime.FuncForPC(f.pc())
//	if fn == nil {
//		return "unknown"
//	}
//	file, _ := fn.FileLine(f.pc())
//	return file
//}
//
//// line returns the line number of source code of the
//// function for this Frame's pc.
//func (f Frame) line() int {
//	fn := runtime.FuncForPC(f.pc())
//	if fn == nil {
//		return 0
//	}
//	_, line := fn.FileLine(f.pc())
//	return line
//}
//
//// name returns the name of this function, if known.
//func (f Frame) name() string {
//	fn := runtime.FuncForPC(f.pc())
//	if fn == nil {
//		return "unknown"
//	}
//	return fn.Name()
//}
//
//// Format formats the frame according to the fmt.Formatter interface.
////
////	%s    source file
////	%d    source line
////	%n    function name
////	%v    equivalent to %s:%d
////
//// Format accepts flags that alter the printing of some verbs, as follows:
////
////	%+s   function name and path of source file relative to the compile time
////	      GOPATH separated by \n\t (<funcname>\n\t<path>)
////	%+v   equivalent to %+s:%d
//func (f Frame) Format(s fmt.State, verb rune) {
//	switch verb {
//	case 's':
//		switch {
//		case s.Flag('+'):
//			io.WriteString(s, f.name())
//			io.WriteString(s, "\n\t")
//			io.WriteString(s, f.file())
//		default:
//			io.WriteString(s, path.Base(f.file()))
//		}
//	case 'd':
//		io.WriteString(s, strconv.Itoa(f.line()))
//	case 'n':
//		io.WriteString(s, funcname(f.name()))
//	case 'v':
//		f.Format(s, 's')
//		io.WriteString(s, ":")
//		f.Format(s, 'd')
//	}
//}
//
//// MarshalText formats a stacktrace Frame as a text string. The output is the
//// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
//func (f Frame) MarshalText() ([]byte, error) {
//	name := f.name()
//	if name == "unknown" {
//		return []byte(name), nil
//	}
//	return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
//}
//
//// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
//type StackTrace []Frame
//
//// Format formats the stack of Frames according to the fmt.Formatter interface.
////
////	%s	lists source files for each Frame in the stack
////	%v	lists the source file and line number for each Frame in the stack
////
//// Format accepts flags that alter the printing of some verbs, as follows:
////
////	%+v   Prints filename, function, and line number for each Frame in the stack.
//func (st StackTrace) Format(s fmt.State, verb rune) {
//	switch verb {
//	case 'v':
//		switch {
//		case s.Flag('+'):
//			for _, f := range st {
//				io.WriteString(s, "\n")
//				f.Format(s, verb)
//			}
//		case s.Flag('#'):
//			fmt.Fprintf(s, "%#v", []Frame(st))
//		default:
//			st.formatSlice(s, verb)
//		}
//	case 's':
//		st.formatSlice(s, verb)
//	}
//}
//
//// formatSlice will format this StackTrace into the given buffer as a slice of
//// Frame, only valid when called with '%s' or '%v'.
//func (st StackTrace) formatSlice(s fmt.State, verb rune) {
//	io.WriteString(s, "[")
//	for i, f := range st {
//		if i > 0 {
//			io.WriteString(s, " ")
//		}
//		f.Format(s, verb)
//	}
//	io.WriteString(s, "]")
//}
//
//// stack represents a stack of program counters.
//type stack []uintptr
//
//func (s *stack) Format(st fmt.State, verb rune) {
//	switch verb {
//	case 'v':
//		switch {
//		case st.Flag('+'):
//			for _, pc := range *s {
//				f := Frame(pc)
//				fmt.Fprintf(st, "\n%+v", f)
//			}
//		}
//	}
//}
//
//func (s *stack) StackTrace() StackTrace {
//	f := make([]Frame, len(*s))
//	for i := 0; i < len(f); i++ {
//		f[i] = Frame((*s)[i])
//	}
//	return f
//}
//
//func callers() *stack {
//	const depth = 32
//	var pcs [depth]uintptr
//	n := runtime.Callers(3, pcs[:])
//	var st stack = pcs[0:n]
//	return &st
//}
//
//// funcname removes the path prefix component of a function's name reported by func.Name().
//func funcname(name string) string {
//	i := strings.LastIndex(name, "/")
//	name = name[i+1:]
//	i = strings.Index(name, ".")
//	return name[i+1:]
//}
